const express = require('express');
const router = express.Router();
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const Joi = require('joi');
const db = require('../../models');
const { authenticateToken } = require('../../middleware/auth');

// 输入验证规则
const registerSchema = Joi.object({
  username: Joi.string().alphanum().min(3).max(30).required(),
  email: Joi.string().email().required(),
  password: Joi.string().min(6).max(128).required(),
  nickname: Joi.string().max(50).optional()
});

const loginSchema = Joi.object({
  username: Joi.string().required(),
  password: Joi.string().required()
});

/**
 * 用户注册
 * POST /api/auth/register
 */
router.post('/register', async (req, res) => {
  try {
    // 输入验证
    const { error, value } = registerSchema.validate(req.body);
    if (error) {
      return res.status(400).json({
        error: '输入数据不合法',
        details: error.details[0].message
      });
    }

    const { username, email, password, nickname } = value;

    // 检查用户名是否已存在
    const existingUser = await db.User.findOne({
      where: { username }
    });

    if (existingUser) {
      return res.status(409).json({
        error: '用户名已存在'
      });
    }

    // 检查邮箱是否已存在
    const existingEmail = await db.User.findOne({
      where: { email }
    });

    if (existingEmail) {
      return res.status(409).json({
        error: '邮箱已被使用'
      });
    }

    // 密码加密
    const saltRounds = parseInt(process.env.BCRYPT_ROUNDS) || 12;
    const hashedPassword = await bcrypt.hash(password, saltRounds);

    // 创建用户
    const user = await db.User.create({
      username,
      email,
      password: hashedPassword,
      nickname: nickname || username,
      status: 'active'
    });

    // 生成JWT令牌
    const token = jwt.sign(
      { userId: user.id, username: user.username },
      process.env.JWT_SECRET,
      { expiresIn: process.env.JWT_EXPIRES_IN || '7d' }
    );

    res.status(200).json({
      message: '注册成功',
      token,
      user: {
        id: user.id,
        username: user.username,
        email: user.email,
        nickname: user.nickname,
        avatar: user.avatar,
        created_at: user.created_at
      }
    });

  } catch (error) {
    console.error('用户注册错误:', error);
    res.status(500).json({
      error: '服务器内部错误'
    });
  }
});

/**
 * 用户登录
 * POST /api/auth/login
 */
router.post('/login', async (req, res) => {
  try {
    // 输入验证
    const { error, value } = loginSchema.validate(req.body);
    if (error) {
      return res.status(400).json({
        error: '输入数据不合法',
        details: error.details[0].message
      });
    }

    const { username, password } = value;

    // 查找用户
    const user = await db.User.findOne({
      where: { username }
    });

    if (!user) {
      return res.status(401).json({
        error: '用户名或密码错误'
      });
    }

    // 验证密码
    const isValidPassword = await bcrypt.compare(password, user.password);
    if (!isValidPassword) {
      return res.status(401).json({
        error: '用户名或密码错误'
      });
    }

    // 检查用户状态
    if (user.status !== 'active') {
      return res.status(401).json({
        error: '用户账户已被禁用'
      });
    }

    // 更新最后登录时间
    await user.update({
      last_login_at: new Date()
    });

    // 生成JWT令牌
    const token = jwt.sign(
      { userId: user.id, username: user.username },
      process.env.JWT_SECRET,
      { expiresIn: process.env.JWT_EXPIRES_IN || '7d' }
    );

    res.json({
      message: '登录成功',
      token,
      user: {
        id: user.id,
        username: user.username,
        email: user.email,
        nickname: user.nickname,
        avatar: user.avatar,
        last_login_at: user.last_login_at
      }
    });

  } catch (error) {
    console.error('用户登录错误:', error);
    res.status(500).json({
      error: '服务器内部错误'
    });
  }
});

/**
 * 刷新令牌
 * POST /api/auth/refresh
 */
router.post('/refresh', authenticateToken, async (req, res) => {
  try {
    const user = req.user;

    // 生成新的JWT令牌
    const token = jwt.sign(
      { userId: user.id, username: user.username },
      process.env.JWT_SECRET,
      { expiresIn: process.env.JWT_EXPIRES_IN || '7d' }
    );

    res.json({
      message: '令牌刷新成功',
      token,
      user: {
        id: user.id,
        username: user.username,
        email: user.email,
        nickname: user.nickname,
        avatar: user.avatar
      }
    });

  } catch (error) {
    console.error('令牌刷新错误:', error);
    res.status(500).json({
      error: '服务器内部错误'
    });
  }
});

/**
 * 获取当前用户信息
 * GET /api/auth/profile
 */
router.get('/profile', authenticateToken, async (req, res) => {
  try {
    const user = req.user;

    res.json({
      user: {
        id: user.id,
        username: user.username,
        email: user.email,
        nickname: user.nickname,
        avatar: user.avatar,
        status: user.status,
        created_at: user.created_at,
        updated_at: user.updated_at,
        last_login_at: user.last_login_at
      }
    });

  } catch (error) {
    console.error('获取用户信息错误:', error);
    res.status(500).json({
      error: '服务器内部错误'
    });
  }
});

/**
 * 更新用户资料
 * PUT /api/auth/profile
 */
router.put('/profile', authenticateToken, async (req, res) => {
  try {
    const user = req.user;
    const { username, email, nickname, avatar, phone, bio, gender, birthday, location } = req.body;

    // 检查用户名是否已被其他用户使用
    if (username && username !== user.username) {
      const existingUser = await db.User.findOne({
        where: { username, id: { [db.Sequelize.Op.ne]: user.id } }
      });
      if (existingUser) {
        return res.status(409).json({ error: '用户名已被使用' });
      }
    }

    // 检查邮箱是否已被其他用户使用
    if (email && email !== user.email) {
      const existingEmail = await db.User.findOne({
        where: { email, id: { [db.Sequelize.Op.ne]: user.id } }
      });
      if (existingEmail) {
        return res.status(409).json({ error: '邮箱已被使用' });
      }
    }

    // 更新用户信息
    const updateData = {};
    if (username) updateData.username = username;
    if (email) updateData.email = email;
    if (nickname !== undefined) updateData.nickname = nickname;
    if (avatar !== undefined) updateData.avatar = avatar;
    if (phone !== undefined) updateData.phone = phone;
    if (bio !== undefined) updateData.bio = bio;
    if (gender !== undefined) updateData.gender = gender;
    if (birthday !== undefined) updateData.birthday = birthday;
    if (location !== undefined) updateData.location = location;

    await user.update(updateData);

    // 获取更新后的用户信息
    const updatedUser = await db.User.findByPk(user.id);

    res.json({
      message: '用户资料更新成功',
      user: updatedUser.toJSON()
    });

  } catch (error) {
    console.error('更新用户资料错误:', error);
    res.status(500).json({
      error: '服务器内部错误'
    });
  }
});

/**
 * 退出登录
 * POST /api/auth/logout
 */
router.post('/logout', authenticateToken, async (req, res) => {
  try {
    // TODO: 如果使用Redis存储黑名单，可以将token加入黑名单
    // 当前JWT是无状态的，所以主要依赖前端删除token
    
    res.json({
      message: '退出登录成功'
    });

  } catch (error) {
    console.error('退出登录错误:', error);
    res.status(500).json({
      error: '服务器内部错误'
    });
  }
});

/**
 * 微信小程序登录
 * POST /api/auth/wechat
 */
router.post('/wechat', async (req, res) => {
  try {
    const { code } = req.body;

    if (!code) {
      return res.status(400).json({
        error: '缺少微信授权码'
      });
    }

    // 这里应该调用微信API获取openid
    // const wxResult = await getWechatOpenId(code);
    
    // 临时处理
    res.json({
      message: '微信登录功能开发中',
      code: 'WECHAT_LOGIN_TODO'
    });

  } catch (error) {
    console.error('微信登录错误:', error);
    res.status(500).json({
      error: '服务器内部错误'
    });
  }
});

module.exports = router; 